import javax.swing.*;
import javax.swing.text.*;
import java.awt.event.*;
import java.awt.*;
import java.text.ParseException;
import javax.swing.border.*;
import java.util.*;
import java.text.*;
import javax.swing.table.*;
/**
 * La clase NewComp proporciona diversos métodos de clase que van desde 
 * conversiones de unidades, cadenas de texto con formato,
 * componentes gráficos configurados, entre otros.
 */
public class NewComp
{
    private NewComp(){}
    /**
     * Realiza la conversión de nanómetros a pulgadas
     * @param nm cantidad de nanómetros a convertir
     * @return cantidad expresada en pulgadas
     */
    public static float nmToIn(int nm)
    {
        return (float)nm/(float)25400000;
    }
    public static float nmToIn(long nm)
    {
        return (float)(nm/25400000);
    }
    /**
     * Realiza la conversión de nanómetros a milímetros
     * @param nm cantidad de nanómetros a convertir
     * @return cantidad expresada en milímetros
     */
    public static float nmToMm(int nm)
    {
        return (float)nm/(float)1000000;
    }
    public static float nmToMm(long nm)
    {
        return (float)(nm/1000000L);
    }
    /**
     * Realiza la conversión de pulgadas a nanómetros
     * @param in cantidad de pulgadas a convertir
     * @return cantidad expresada en nanómetros
     */
    /*public static int inToNm(float in)
    {
        return (int)(in*25400000);
    }*/
    public static long inToNm(float in)
    {
        return (long)(in*25400000);
    }
    /**
     * Realiza la conversión de milímetros a nanómetros
     * @param mm cantidad de milímetros a convertir
     * @return cantidad expresada en nanómetros
     */
    /*public static int mmToNm(float mm)
    {
        return (int)(mm*1000000);
    }*/
    public static long mmToNm(float mm)
    {
        return (long)(mm*1000000L);
    }
    /**
     * Proporciona una barra de progreso con texto formateado
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * que se define en el archivo FontOptions.properties
     * @return una barra de progreso con texto formateado
     */
    public static JProgressBar getProgressBar(String sizeFont)
    {
        JProgressBar pBar = new JProgressBar();        
        pBar.setFont(
            new Font("SansSerif",Font.BOLD,getIntSizeFont(sizeFont)));
        pBar.setStringPainted(true);
        return pBar;
    }
    /**
     * Proporciona un control deslizante con marcas inteligentes que 
     * se adaptan a los valores mínimo y máximo.
     * @param min valor mínimo del control
     * @param max valor máximo del control
     * @param value valor inicial
     * @return un control deslizante
     */
    public static JSlider getSlider(int min, int max, int value)
    {
        JSlider slider;
        if((min == max)||(value < min)||(value > max))
            return new JSlider();
        slider = new JSlider(SwingConstants.VERTICAL, min, max, value);
        int majorTick;
        if(min == 0)
            majorTick = mcd(max,max/3);
        else
            majorTick = mcd(max,min);
        if(majorTick > 0)
            if((max-min)/majorTick > 10)
                majorTick = max/4;
        slider.setMajorTickSpacing(majorTick);
        slider.setMinorTickSpacing(mcd(majorTick,majorTick/2));
        slider.setPaintTicks(true);
        slider.setPaintLabels(true);
        slider.putClientProperty("JComponent.sizeVariant", "large");
        slider.setFont(
            new Font("SansSerif",Font.BOLD,getIntSizeFont("titleTagsSlider")));
        return slider;
    }
    /**
     * Proporciona un control deslizante
     * @param minorTick espacio entre las marcas pequeñas
     * @param majorTick espacio entre las marcas grandes
     * @param min valor mínimo del control
     * @param max valor máximo del control
     * @param value valor inicial
     * @return un control deslizante
     */
    public static JSlider getSlider(int minorTick, int majorTick,int min,int max,int value)
    {
        JSlider slider = new JSlider( min, max, value);
        slider.setMajorTickSpacing(majorTick);
        slider.setMinorTickSpacing(minorTick);
        slider.setPaintTicks(true);
        slider.setPaintLabels(true);
        slider.putClientProperty("JComponent.sizeVariant", "large");
        slider.setFont(
            new Font("SansSerif",Font.BOLD,getIntSizeFont("titleTagsSlider")));
        return slider;
    }
    /**
     * Proporciona un botón de radio
     * @param text el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties, y se establce
     * en el rótulo del componente
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param color establece el color de la fuente
     * @param isSelected establece el botón como seleccionado si es verdadero o
     * no seleccionado si es falso
     * @param listener el oyente de eventos del botón
     * @return un botón de radio
     */
    public static JRadioButton getRadioButton(String text, 
                                              String sizeFont, 
                                              String color, 
                                              boolean isSelected, 
                                              ActionListener listener)
    {
        JRadioButton button = new JRadioButton( 
            "<html><FONT color= "+
            color+" size= "+
            getStringFontSize(sizeFont)+
            " ><B>"+
            stringBundle.getString(text)+
            "</B></FONT></html>", isSelected
            );
        button.putClientProperty("JComponent.sizeVariant", "large");
        button.addActionListener(listener);
        return button;
    }
    /**
     * Proporciona un botón con una cadena de texto formateada
     * @param text el nombre clave que identifica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties, y se establece
     * en el rótulo del componente
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param color establece el color de la fuente
     * @param listener el oyente de eventos del botón
     */
    public static JButton getButton(String text, 
                                    String sizeFont,
                                    String color,
                                    ActionListener listener)
    {
        JButton button = new JButton( 
            "<html><FONT color= "+color+" size= "+
            getStringFontSize(sizeFont)+
            " ><B>"+
            stringBundle.getString(text)+
            "</B></FONT></html>"
            );
        button.putClientProperty("JComponent.sizeVariant", "large");
        button.addActionListener(listener);
        return button;
    }
    /**
     * Proporciona un botón con una cadena de texto formateada y un ícono
     * @param text el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties, y se establce
     * en el rótulo del componente
     * @param iconName el nombre clave con que se relaciona al ícono en la clase Resources
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param color establece el color de la fuente
     * @param listener el oyente de eventos del botón
     */
    public static JButton getButton(
        String text, 
        String iconName, 
        String sizeFont,
        String color,
        ActionListener listener)
    {
        JButton button = new JButton( 
            "<html><FONT color= "+color+" size= "+
            getStringFontSize(sizeFont)+
            " ><B>"+
            stringBundle.getString(text)+
            "</B></FONT></html>",
            getIcon(iconName)
        );
        button.putClientProperty("JComponent.sizeVariant", "large");
        button.addActionListener(listener);
        return button;
    }
    /**
     * Proporciona un botón con un ícono
     * @param iconName el nombre clave con que se relaciona al ícono en la clase Resources
     * @param listener el oyente de eventos del botón
     */
    public static JButton getButton(String iconName, ActionListener listener)
    {
        JButton button = new JButton( getIcon(iconName));
        button.putClientProperty("JComponent.sizeVariant", "large");
        button.addActionListener(listener);
        return button;
    }
    /**
     * Proporciona un botón con un ícono y un oyente de eventos del ratón
     * @param iconName el nombre con que se relaciona al ícono en la clase Resources
     * @param listener el oyente de eventos del ratón
     */
    public static JButton getButton(String iconName, MouseListener listener)
    {
        JButton button = new JButton( getIcon(iconName));
        button.putClientProperty("JComponent.sizeVariant", "large");
        button.addMouseListener(listener);
        return button;
    }
    /**
     * Proporciona una lámina con borde
     * @param layout establece el encargado de disposición de este contenedor
     * @return una lámina con borde
     */
    public static JPanel getPanel(LayoutManager layout)
    {
        JPanel panel = new JPanel();
        panel.setLayout(layout);        
        Border etchedBorder = BorderFactory.createEtchedBorder();
        panel.setBorder(etchedBorder);
        return panel;
    }
    /**
     * Proporciona una lámina con borde y título
     * @param text el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties, y se establce
     * en el rótulo del componente
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param layout establece el encargado de disposición de este contenedor
     * @return una lámina con borde y título
     */
    public static JPanel getPanel(String text, 
                                  String sizeFont, 
                                  LayoutManager layout)
    {
        JPanel panel = new JPanel();
        panel.setLayout(layout);        
        Border etchedBorder = BorderFactory.createEtchedBorder();
        Border borderWT = BorderFactory.createTitledBorder(
            etchedBorder, 
            stringBundle.getString(text), 
            TitledBorder.LEFT, 
            TitledBorder.TOP, 
            new Font("SansSerif",Font.BOLD,getIntSizeFont(sizeFont))
            );
        panel.setBorder(borderWT);
        return panel;
    }
    /**
     * Proporciona una lámina con borde y título
     * @param text_1 el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties, y se establce
     * en el rótulo del componente
     * @param text_2 es una cadena que se agrega despues de text_1 y
     * puede ser cualquier texto
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param layout establece el encargado de disposición de este contenedor
     * @return una lámina con borde y título
     */
    public static JPanel getPanel(String text_1, 
                                  String text_2, 
                                  String sizeFont, 
                                  LayoutManager layout)
    {
        JPanel panel = new JPanel();
        panel.setLayout(layout);        
        Border etchedBorder = BorderFactory.createEtchedBorder();
        Border borderWT = BorderFactory.createTitledBorder(
            etchedBorder, 
            stringBundle.getString(text_1)+" "+
            text_2+"", 
            TitledBorder.LEFT, 
            TitledBorder.TOP, 
            new Font("SansSerif",Font.BOLD,getIntSizeFont(sizeFont))
            );
        panel.setBorder(borderWT);
        return panel;
    }
    /**
     * Proporciona una etiqueta con texto formateado
     * @param text el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties, y se establce
     * en el rótulo del componente
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param color establece el color de la fuente
     * @return una etiqueta
     */
    public static JLabel getLabel(String text, String sizeFont, String color)
    {
        JLabel label =  new JLabel(
            "<html><FONT color="+color+
            " size="+getStringFontSize(sizeFont)+
            " ><B>&nbsp;&nbsp;"+stringBundle.getString(text)+
            "</B></FONT></html>"
            );
        label.setFocusable(false);
        return label;
    }
    /**
     * Proporciona una etiqueta con texto formateado
     * @param text la cadena que se establece en el componente
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return una etiqueta
     */
    public static JLabel getLabel(String text,String sizeFont)
    {
        JLabel label =  new JLabel(stringBundle.getString(text));
        label.setFont(
            new Font("SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        label.setFocusable(false);
        return label;
    }
    /**
     * Proporciona una etiqueta con un ícono y sin texto
     * @param iconName el nombre clave con que se relaciona al ícono en la clase Resources
     * @return una etiqueta con un ícono
     */
    public static JLabel getLabelIcon(String iconName)
    {
        JLabel label = new JLabel(getIcon(iconName));
        label.setFocusable(false);
        return label;
    }
    /**
     * Proporciona una etiqueta que no puede obtener el foco
     * return una etiqueta
     */
    public static JLabel getLabel()
    {
        JLabel label = new JLabel();
        label.setFocusable(false);
        return label;
    }
    /**
     * Proporciona un campo de texto formateado que no es editable ni puede tener el foco
     * @param text el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties, y se establce
     * en el campo
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un campo de texto
     */
    public static JTextField getTxtField(String text, String sizeFont)
    {
        JTextField txtField = new JTextField(stringBundle.getString(text),10);
        txtField.setFont(new Font( "SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        txtField.setEditable(false);
        txtField.setFocusable(false);
        return txtField;
    }
    /**
     * Proporciona un campo de texto formateado y editable
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un campo de texto editable
     */
    public static JTextField getTxtFieldEditable(String sizeFont)
    {
        JTextField txtField = new JTextField(10);
        txtField.setFont(new Font( "SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        return txtField;
    }
    /**
     * Proporciona un campo de texto con formato numérico de coma flotante y editable
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un campo de texto editable
     */
    public static JFormattedTextField getNumberTxtField(String sizeFont)
    {
        JFormattedTextField field = 
            new JFormattedTextField(NumberFormat.getNumberInstance());
        field.setFont(new Font( "SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        field.setColumns(10);
        return field;
    }
    /**
     * Proporciona un campo de texto con formato numérico entero y editable
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un campo de texto editable
     */
    public static JFormattedTextField getIntegerTxtField(String sizeFont)
    {
        JFormattedTextField field = 
            new JFormattedTextField(NumberFormat.getIntegerInstance());
        field.setFont(new Font( "SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        field.setColumns(10);
        return field;
    }
    /**
     * Proporciona un selector múltiple con texto formateado
     * @param sizeFont nombre clave que establece el tamaño de la fuente 
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un selector múltiple
     */
    public static JComboBox getComboBox(String sizeFont)
    {
        JComboBox combo = new JComboBox();
        combo.setFont(new Font( "SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        return combo;
    }
    /**
     * Proporciona un área de texto formatedo
     * @param rows establece el numero de filas del área
     * @param columns establece el numero de columnas del área
     * @param sizeFont nombre clave que establece el tamaño de la fuente 
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param bold establece la fuente como negrita cuando es verdadero y como
     * plano cuando es falso
     * @return un área de texto
     */
    public static JTextArea getTextArea(int rows,int columns,String sizeFont,boolean bold)
    {
        JTextArea textArea = new JTextArea(new PlainDocument(),"",rows,columns);
        int fontType;
        if(bold)
            fontType = Font.BOLD;
        else 
            fontType = Font.PLAIN;
        textArea.setFont(new Font("monospaced", fontType, getIntSizeFont(sizeFont)));
        return textArea;
    }
    /**
     * Proporciona una tabla específicamente para visualizar un directorio
     * @param name lista de los nombres de los archivos
     * @param size lista de los tamaños de los archivos
     * @param date lista de las fechas de modificación de los archivos
     * @param sizeFont nombre clave que establece el tamaño de la fuente 
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return una tabla
     */
    public static JTable getTable(String[] name,Integer[] size,String[] date,String sizeFont)
    {
        JTable table = new JTable(BrowserTable.getBrowserTable(name,size,date));
        table.setFont(new Font( "SansSerif", Font.PLAIN, getIntSizeFont(sizeFont)));
        return table;
    }
    /**
     * Proporciona un modelo de tabla específicamente para visualizar un directorio
     * @param name lista de los nombres de los archivos
     * @param size lista de los tamaños de los archivos
     * @param date lista de las fechas de modificación de los archivos
     * @return un modelo de tabla
     */
    public static TableModel getTableModel(String[] name,Integer[] size,String[] date)
    {
        return BrowserTable.getBrowserTable(name,size,date);
    }
    /**
     * Proporciona un campo de texto formateado para visualizar cantidades que 
     * esten expresadas en nanómetros a milímetros o pulgadas dependiendo 
     * del sistema métrico establecido. No es editable ni puede obtener el foco
     * @param isSi establece el sistema métrico internacional si es verdadero o 
     * ingles si es falso
     * @param sizeFont nombre clave que establece el tamaño de la fuente 
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un campo de texto numérico
     */
    public static JFormattedTextField getFTF(boolean isSi, String sizeFont)
    {
        JFormattedTextField xField = 
            new JFormattedTextField(NumberFormatter.getFormat(isSi));
        xField.setFont(
            new Font( "SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        xField.setEditable(false);
        xField.setFocusable(false);
        xField.setValue(new Float(0));
        return xField;
    }
    /**
     * Proporciona un campo de texto formateado para cantidades enteras, no editable y 
     * no puede obtener el foco
     * @param whole establece el numero máximo de cifras visibles
     * @param sizeFont nombre clave que establece el tamaño de la fuente 
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un campo de texto formateado
     */
    public static JFormattedTextField getFTF(int whole, String sizeFont)
    {
        JFormattedTextField xField = 
            new JFormattedTextField(IntFormatter.getFormat(whole));
        xField.setFont(
            new Font( "SansSerif", Font.BOLD, getIntSizeFont(sizeFont)));
        xField.setEditable(false);
        xField.setFocusable(false);
        xField.setValue(new Integer(0));
        return xField;
    }
    /**
     * Proporciona una cadena de texto con formato html
     * @param text el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @param color establece el color de la fuente
     * @return una cadena de texto con formato html
     */
    public static String getStringWithFormat(String text, String sizeFont, String color)
    {
        return "<html><FONT color="+
            color+" size="+getStringFontSize(sizeFont)+
            " ><B>&nbsp;&nbsp;"+stringBundle.getString(text)+
            "</B></FONT></html>";
    }
    /**
     * Proporciona una cadena de texto que corresponde al nombre clave
     * proporcionado
     * @param text el nombre clave que identfica a una cadena de texto,
     * la cual se define en el archivo StringsGui.properties
     * @return una cadena de texto
     */
    public static String getString(String text)
    {
        return stringBundle.getString(text);
    }
    /**
     * Proporciona un ícono
     * @param iconName el nombre clave con que se relaciona al ícono en la clase Resources
     * @return un ícono
     */
    public static ImageIcon getIcon(String key)
    {
        Resources res = new Resources();
        if(key.equals("on"))
            key = "enabled";
        if(key.equals("off"))
            key = "disabled";
        return (ImageIcon) res.handleGetObject(key);
    }
    /**
     * Cambia la cadena inicial de los nombres claves de los tamaños 
     * de fuente, con el fin de usar los mismos nombres clave en el mismo archivo,
     * pero con distinto valor
     * @param fontId nuevo identficador de un grupo de fuentes que debe ser definido 
     * en el archivo FontOptions.properties
     */
    public static void changeFont(String fontId)
    {
        fontOption = fontId+"_";
    }
    /*public static void frameProof()
    {
        JFrame frame = new JFrame();
        frame.setSize(400,300);
        frame.setVisible(true);
    }
    public static void frameProof(long id,long value)
    {
        JFrame frame = new JFrame();
        JTextArea area = new JTextArea();
        area.setText("(id: "+id+", value: "+value+")");
        frame.add(area);
        frame.setSize(400,300);
        frame.setVisible(true);
    }*/
    /**
     * Proporciona el máximo común divisor de dos números 
     * @param b un número entero
     * @param c un número entero
     * @return el máximo común divisor
     */
    private static int mcd(int b,int c)
    {
        int r = 0;
        if(Math.abs(b)<Math.abs(c))
        {
            r = Math.abs(b);
            b = Math.abs(c);
            c = r;
            r = 0;
        } else
        {
            b = Math.abs(b);
            c = Math.abs(c);
        }
        if(c == 0) return b;
        r=b-c*(int)(b/c);
        if(r == 0) return c;
        else return mcd(c,r);
    }
    /**
     * Proporciona el valor entero correspondiente al nombre clave del tamaño de fuente
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return un número entero
     */
    private static int getIntSizeFont(String sizeFont)
    {
        Integer intValue = new Integer(fontBundle.getString(fontOption+sizeFont));
        return intValue.intValue();
    }
    /**
     * Proporciona el valor correspondiente al nombre clave del tamaño de 
     * fuente como cadena de texto
     * @param sizeFont nombre clave que establece el tamaño de la fuente
     * y cuyo valor es definido en el archivo FontOptions.properties
     * @return una cadena de texto
     */
    private static String getStringFontSize(String fontSize)
    {
        return fontBundle.getString(fontOption+fontSize);
    }
    private static class BrowserTable extends AbstractTableModel
    {
        private BrowserTable( String[] name_,Integer[] size_,String[] date_)
        {
            name = name_;
            size = size_;
            date = date_;
        }
        public int getRowCount()
        {
            return name.length;
        }
        public int getColumnCount()
        {
            return 3;
        }
        public Object getValueAt(int row, int column)
        {
            if(column == 0)
                return name[row];
            else if(column == 1)
            {
                if(row < size.length)
                    return new String(size[row]+" b");
                else
                    return "0 b";
            }
            else
            { 
                if(row < date.length)
                    return date[row];
                else
                    return "unknown";
            }
        }
        public String getColumnName(int c)
        {
            String[] heading = { 
                getStringWithFormat("name", "titleColums", "black"),
                getStringWithFormat("size", "titleColums", "black"),
                getStringWithFormat("modified", "titleColums", "black")
            };
            //stringBundle.getString("modified")
            return heading[c];
        }
        public static BrowserTable getBrowserTable(String[] name_,Integer[] size_,String[] date_)
        {
            return new BrowserTable(name_,size_,date_);
        }
        private String[] name;
        private String[] date;
        private Integer[] size;
    }
    private static class NumberFormatter extends DefaultFormatter
    {
        private NumberFormatter(boolean isSi)
        {
            isSi_ = isSi;
        }
        public String valueToString(Object value) throws ParseException
        {
            if(!(value instanceof Integer))
                throw new ParseException("Not a Integer", 0);
            Float value_;
            if(isSi_)
                value_ = new Float(nmToMm((Integer)value));
            else
                value_ = new Float(nmToIn((Integer)value));
            String string_ = " 00000.000";
            if(value_.floatValue() == 0)
                if(isSi_)
                    return " 00000.000";
                else
                    return " 0000.0000";
            int whole = value_.intValue();
            float decimal = value_.floatValue() - (float)whole;
            if(value_.floatValue() < 0)
            {
                string_ = "-";
                whole *= -1;
                decimal *= -1;
            }
            else
                string_ = " ";
            int aux = 0;
            if(isSi_)
                aux = 10000;
            else
                aux = 1000;
            if(whole == 0)
                if(isSi_)
                    string_ = string_ + "0000";
                else
                    string_ = string_ + "000";
            else
                while((whole/aux) < 1)
                {
                    string_ = string_ +"0";
                    aux /= 10;
                }
            if(decimal == 0)
                if(isSi_)
                    return string_ +whole+".000";
                else
                    return string_ +whole+".0000";
            else
            {
                String string_aux = "";
                aux = 10;
                while(decimal*aux < 1)
                {
                    string_aux += "0";
                    aux *= 10;
                }
            
                if(isSi_)
                    return string_ +whole+"."+string_aux+new Integer((int)(decimal*1000));
                else
                    return string_ +whole+"."+string_aux+new Integer((int)(decimal*10000));
            }
        }
        public Object stringToValue(String text) throws ParseException
        {
            Float value_ = new Float(0);
            try
            {
                value_ = new Float(text);
            }
            catch(NumberFormatException nfe)
            {
                value_ = new Float(0);
            }
            return value_;
        }
        public static NumberFormatter getFormat(boolean isSi)
        {
            return new NumberFormatter(isSi);
        }
        private boolean isSi_;
    }
    private static class IntFormatter extends DefaultFormatter
    {
        private int whole_;
        private IntFormatter(int whole)
        {
            whole_ = whole;
        }
        public String valueToString(Object value) throws ParseException
        {
            if(!(value instanceof Integer))
                throw new ParseException("Not a Integer", 0);
            Integer value_ = (Integer) value;
            String string_ = "";
            int whole = value_.intValue();
            if(value_.intValue() < 0)
                whole *= -1;
            int aux;
            if(whole == 0)
            {
                aux = (int)Math.pow((double)10,(double)whole_);
                while(aux/10 > 1)
                {
                    string_ = string_ + "0";
                    aux /= 10;
                }
            }
            else
            {
                aux = (int)Math.pow((double)10,(double)whole_-1);
                while((whole/aux) < 1)
                {
                    string_ = string_ +"0";
                    aux /= 10;
                }
            }
            return string_ +whole;
        }
        public Object stringToValue(String text) throws ParseException
        {
            Integer value_ = new Integer(0);
            try{
                value_ = new Integer(text);
            }
            catch(NumberFormatException nfe)
            {
                value_ = new Integer(0);
            }
            return value_;
        }
        public static IntFormatter getFormat(int whole)
        {
            return new IntFormatter(whole);
        }
    }
    static
    {
        fontOption = "default_";
        fontBundle = ResourceBundle.getBundle("resource.FontOptions.530x320");
        stringBundle = ResourceBundle.getBundle("resource.StringsGui");
    }
    private static String fontOption;
    private static ResourceBundle fontBundle;
    private static ResourceBundle stringBundle;
    //public static Proof proofFrame = new Proof();
}
